home *** CD-ROM | disk | FTP | other *** search
/ PC Graphics Unleashed / PC Graphics Unleashed.iso / ch03 / color.c next >
C/C++ Source or Header  |  1993-05-21  |  7KB  |  237 lines
  1. /****************************************************************
  2. * FILE:    color.c
  3. * DESC:    This file contains the color routines used by morph,
  4. *        dissolve and fix.
  5. * 
  6. * HISTORY:    Created     3/18/1993
  7. * LAST CHANGED: 5/ 6/1993
  8. * 
  9. *    Copyright (c) 1992 by Scott Anderson
  10. *
  11. ****************************************************************/
  12.  
  13. #include <stdio.h>
  14. #include <memory.h>
  15.  
  16. #include "define.h"
  17.  
  18. /* ----------------------DEFINES------------------------------ */
  19.  
  20. /* ----------------------TYPEDEFS/STRUCTS--------------------- */
  21.  
  22. /* ----------------------PROTOTYPES--------------------------- */
  23.  
  24. int        closestColor(int r, int g, int b, PALETTE *palPtr);
  25. void    collapseColors(PALETTE *palPtr);
  26. int        mergePalette(PICTURE *pic);
  27. int        remapPicture(PICTURE *picPtr, PALETTE *palPtr);
  28. int        initFreq();
  29.  
  30. /* ----------------------EXTERNALS---------------------------- */
  31.  
  32. /* set from last picture loaded */
  33. extern int        Xmin, Ymin, Xmax, Ymax;
  34.  
  35. /* ----------------------GLOBAL DATA-------------------------- */
  36.  
  37. /* number of colors in tweened image before reduction*/
  38. int     Ncolors;
  39.  
  40. /* r, g, b frequency counter array */
  41. unsigned int far Freq[MAX_COMP][MAX_COMP][MAX_COMP];
  42.  
  43. /* tweened images red, grn, and blu components*/
  44. unsigned char far Red[MAX_WIDE][MAX_TALL];
  45. unsigned char far Grn[MAX_WIDE][MAX_TALL];
  46. unsigned char far Blu[MAX_WIDE][MAX_TALL];
  47.  
  48. PALETTE TweenPal;            /* resulting palette */
  49.  
  50. /*****************************************************************
  51. * FUNC: void    collapseColors(PALETTE *palPtr)
  52. * 
  53. * DESC: Collapse the colors in the Freq table until
  54. *        Ncolors < COLORS, then put it in the given color palette.
  55. *****************************************************************/
  56.  
  57. void
  58. collapseColors(PALETTE *palPtr)
  59. {
  60.     int freqCutoff;
  61.     int r, g, b;
  62.     int index;
  63.     int ncolors;
  64.  
  65.     static int freqCount[MAX_FREQ+1];
  66.  
  67.     memset(freqCount, 0, sizeof freqCount);
  68.     for (r = 0; r < MAX_COMP; r++)
  69.         for (g = 0; g < MAX_COMP; g++)
  70.             for (b = 0; b < MAX_COMP; b++)
  71.                 freqCount[Freq[r][g][b]]++;
  72.  
  73.     ncolors = 0;
  74.     for (freqCutoff = COLORS-1; freqCutoff > 1; freqCutoff--) {
  75.         ncolors += freqCount[freqCutoff];
  76.         if (ncolors > COLORS) break;
  77.     }
  78.  
  79.     /* Collapse color space to 256 colors */
  80.     r = g = b = 0;
  81.     while (Ncolors >= COLORS) {
  82.         for (; r < MAX_COMP; r++, g=0) {
  83.             for (; g < MAX_COMP; g++, b=0) {
  84.                 for (; b < MAX_COMP; b++) {
  85.                     if (Freq[r][g][b] && Freq[r][g][b]
  86.                                                 <= freqCutoff) 
  87.                         goto castOut;    /* the ultimate no no */
  88.                 }
  89.             }
  90.         }
  91.         r = g = b = 0;
  92.         freqCutoff++;
  93.         continue;
  94.     castOut:
  95.         Freq[r][g][b] = 0;    /* just remove this low freq color */
  96.         Ncolors--;
  97.     }
  98.  
  99.     /* build a palette out of all the remaining non zero freq's */
  100.     index = 0;
  101.     for (r = 0; r < MAX_COMP; r++)
  102.         for (g = 0; g < MAX_COMP; g++)
  103.             for (b = 0; b < MAX_COMP; b++)
  104.                 /* we have a color we need to map */
  105.                 if (Freq[r][g][b]) {
  106.                     palPtr->c[index].r = r;
  107.                     palPtr->c[index].g = g;
  108.                     palPtr->c[index].b = b;
  109.                     /* remember index in palette */
  110.                     Freq[r][g][b] = index;
  111.                     index++;
  112.                 }
  113. }
  114.  
  115. /*****************************************************************
  116. * FUNC: int    closestColor(int r, int g, int b, PALETTE *palPtr)
  117. * 
  118. * DESC: return the palette index of the color closest to rgb.
  119. *****************************************************************/
  120.  
  121. int
  122. closestColor(int r, int g, int b, PALETTE *palPtr)
  123. {
  124.     int index;
  125.     int distance;
  126.     int min_distance = 3200;    /* a big number */
  127.     int min_index;
  128.  
  129.     /* The value in Freq is now the index into the color table */
  130.     if (Freq[r][g][b]) return Freq[r][g][b];
  131.  
  132.     /* If zero, search for the closest color */
  133.     for (index = 1; index < Ncolors; index++) {
  134.         /* this is really the distance squared, but it works */
  135.         distance =    SQUARE (r - palPtr->c[index].r) +
  136.                     SQUARE (g - palPtr->c[index].g) +
  137.                     SQUARE (b - palPtr->c[index].b);
  138.         if (distance < min_distance) {
  139.             min_distance = distance;
  140.             min_index = index;
  141.             if (distance <= 2) break;    /* close enough! */
  142.         }
  143.     }
  144.     /* New index - for future reference */
  145.     Freq[r][g][b] = min_index;
  146.     return min_index;
  147. }
  148.  
  149. /*****************************************************************
  150. * FUNC: int    mergePalette(PICTURE *picPtr)
  151. * 
  152. * DESC: Merge a palette into Freq count table.
  153. *****************************************************************/
  154.  
  155. int
  156. mergePalette(PICTURE *picPtr)
  157. {
  158.     int     r, g, b;
  159.     unsigned int     pos;
  160.     unsigned char    index;
  161.     PALETTE *palPtr = &picPtr->pal;
  162.     unsigned char far *bufPtr = picPtr->pixmap;
  163.  
  164.     for (pos = 0; pos < MAX_BYTES; pos++) {
  165.         index = *bufPtr++;
  166.         r = palPtr->c[index].r;
  167.         g = palPtr->c[index].g;
  168.         b = palPtr->c[index].b;
  169.         if (Freq[r][g][b] == 0)        /* A new color */
  170.             Ncolors++;
  171.         if (Freq[r][g][b] < MAX_FREQ)    /* Keep it managable */
  172.             Freq[r][g][b]++;
  173.     }
  174. }
  175.  
  176. /*****************************************************************
  177. * FUNC: int    remapPicture(PICTURE *picPtr, PALETTE *palPtr)
  178. * 
  179. * DESC: Remap a picture with a different palette.
  180. *****************************************************************/
  181.  
  182. int
  183. remapPicture(PICTURE *picPtr, PALETTE *palPtr)
  184. {
  185.     int        x, y;
  186.     int     index;
  187.     int        r, g, b;
  188.     unsigned int    pos;
  189.     unsigned char     lookup[COLORS];
  190.     unsigned char far *bufPtr;
  191.     
  192.     /* Create the cross-reference lookup table */
  193.     for (index = 0; index < COLORS; index++) {
  194.         r = picPtr->pal.c[index].r;
  195.         g = picPtr->pal.c[index].g;
  196.         b = picPtr->pal.c[index].b;
  197.         lookup[index] = closestColor(r, g, b, palPtr);
  198.     }
  199.     
  200.     /* Save the new palette in the picture's palette */
  201.     for (index = 0; index < COLORS; index++) {
  202.         picPtr->pal.c[index].r = palPtr->c[index].r;
  203.         picPtr->pal.c[index].g = palPtr->c[index].g;
  204.         picPtr->pal.c[index].b = palPtr->c[index].b;
  205.     }
  206.  
  207.     /* Remap the individual pixels to point to the new colors */
  208.     for (bufPtr = picPtr->pixmap, pos = 0; pos < MAX_BYTES;
  209.                                                 bufPtr++, pos++)
  210.         *bufPtr = lookup[*bufPtr];
  211. }
  212. /*****************************************************************
  213. * FUNC: int    initFreq()
  214. * 
  215. * DESC: zero out the frequency color space table
  216. *****************************************************************/
  217.  
  218. int
  219. initFreq()
  220. {
  221.     int bytes = (sizeof Freq) / 2;
  222.  
  223.     _fmemset(Freq, 0, bytes);
  224.     /* divide because of element size */
  225.     _fmemset(Freq+(bytes/sizeof *Freq), 0, bytes);
  226.  
  227.     /* Guarantee a black color */
  228.     Freq[0][0][0] = MAX_FREQ;
  229.     /* a grey color */
  230.     Freq[MID_COMP-1][MID_COMP-1][MID_COMP-1] = MAX_FREQ;
  231.     /* and a white color */
  232.     Freq[(long)MAX_COMP-1][MAX_COMP-1][MAX_COMP-1] = MAX_FREQ;
  233.     Ncolors = 3;
  234. }
  235.     
  236.  
  237.